{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个实例中，我们使用tensorflow来实现一个简单的手写数字识别的网络，并用这个网络来做个\n",
    "简单的识别示例。\n",
    "\n",
    "首先导入一些用到的库。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:50.515650Z",
     "start_time": "2018-06-01T06:32:43.133728Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "import keras\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T05:39:48.304594Z",
     "start_time": "2018-06-01T04:55:17.674707Z"
    }
   },
   "source": [
    "先来看看数据长什么样子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.075054Z",
     "start_time": "2018-06-01T06:32:50.518290Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.\n",
      "Extracting /data/train-images-idx3-ubyte.gz\n",
      "Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.\n",
      "Extracting /data/train-labels-idx1-ubyte.gz\n",
      "Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.\n",
      "Extracting /data/t10k-images-idx3-ubyte.gz\n",
      "Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.\n",
      "Extracting /data/t10k-labels-idx1-ubyte.gz\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"/data/\", one_hot=True)\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T05:49:40.128071Z",
     "start_time": "2018-06-01T05:49:40.123888Z"
    }
   },
   "source": [
    "可以看到images里面有数量不等的图片，每张图片是28x28长度的一个一维向量，\n",
    "所以用的时候需要先给它还原成28x28的二维图片。labels中则是图片对应的数字的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.695746Z",
     "start_time": "2018-06-01T06:32:51.077167Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4, 4, idx + 1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(np.argmax(mnist.train.labels[idx])))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28, 28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "\n",
    "这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个bool类型的变量用于标识当前网络是否正在训练。\n",
    "\n",
    "为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.706044Z",
     "start_time": "2018-06-01T06:32:51.698913Z"
    }
   },
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784], name='x')\n",
    "y = tf.placeholder(\"float\", [None, 10], name='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为我们输入的是图片展开后的一维向量，所以第一步就需要先把一维向量还原为二维的图片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.719298Z",
     "start_time": "2018-06-01T06:32:51.707730Z"
    }
   },
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x, [-1, 28, 28, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:07:36.530623Z",
     "start_time": "2018-06-01T06:07:36.522665Z"
    }
   },
   "source": [
    "接下来，我们定义第一个卷积层，使用6个5X5的卷积核对输入数据进行卷积，\n",
    "padding方式选择valid，所以输出数据的宽高变为24x24,但是深度已经从原来的1变成了6。\n",
    "本层卷积的激活函数为relu。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.764292Z",
     "start_time": "2018-06-01T06:32:51.721295Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('conv1'):\n",
    "    C1 = tf.contrib.slim.conv2d(\n",
    "        x_image, 6, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来进行stride为2的最大池化，池化后，输出深度不变，但是长宽减半，所以输出变成了12x12,深度6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.774112Z",
     "start_time": "2018-06-01T06:32:51.766784Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('pool1'):\n",
    "    S2 = tf.contrib.slim.max_pool2d(C1, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:10:16.678485Z",
     "start_time": "2018-06-01T06:10:16.671472Z"
    }
   },
   "source": [
    "接下来，我们定义第二个卷积层，使用16个5X5的卷积核对输入数据进行卷积，\n",
    "padding方式还是选择valid，输出8x8,深度为16，本层卷积的激活函数为relu。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.805912Z",
     "start_time": "2018-06-01T06:32:51.776959Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('conv2'):\n",
    "    C3 = tf.contrib.slim.conv2d(\n",
    "        S2, 16, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再进行一次stride为2的最大池化，输出为4x4,深度16。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.814748Z",
     "start_time": "2018-06-01T06:32:51.807560Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('pool2'):\n",
    "    S4 = tf.contrib.slim.max_pool2d(C3, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "池化后的数据是3维的，这里做一个拉平的操作，将3维数据展开到1维，然后送入两层全连接，全连接隐层中神经元个数分别为120，84。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.856740Z",
     "start_time": "2018-06-01T06:32:51.817287Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'keras' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-14-f3401c2ad001>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'fc2'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m     \u001b[0mF6\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mkeras\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mC5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m84\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mactivation_fn\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'keras' is not defined"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('fc1'):\n",
    "    S4_flat = tf.contrib.slim.flatten(S4)\n",
    "    C5 = tf.contrib.slim.fully_connected(\n",
    "        S4_flat, 120, activation_fn=tf.nn.relu)\n",
    "\n",
    "with tf.name_scope('fc2'):\n",
    "    F6 = keras.layers.flatten(C5, 84, activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:17:39.880958Z",
     "start_time": "2018-06-01T06:17:39.869797Z"
    }
   },
   "source": [
    "###### 对特征添加一个0.6的dropout，以40%的概率丢弃特征中的某些数据，\n",
    "这样可以提高网络的推广能力，减少过拟合的可能性。\n",
    "\n",
    "需要注意的是，dropout仅在训练的时候使用，验证的时候，需要关闭dropout，\n",
    "所以验证时候的keep_prob是1.0。\n",
    "\n",
    "dropout的输出最终送入一个隐层为10的全连接层，这个全连接层即为最后的分类器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.913419Z",
     "start_time": "2018-06-01T06:32:51.860766Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('dropout'):\n",
    "    keep_prob = tf.placeholder(name='keep_prob', dtype=tf.float32)\n",
    "    F6_drop = tf.nn.dropout(F6, keep_prob)\n",
    "\n",
    "with tf.name_scope('fc3'):\n",
    "    logits = tf.contrib.slim.fully_connected(F6_drop, 10, activation_fn=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来定义loss和用于优化网络的优化器。loss计算使用了sparse_softmax_cross_entropy_with_logits,\n",
    "这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为0.3。\n",
    "\n",
    ">试试看，增大减小学习率，换个优化器再进行训练会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:52.084738Z",
     "start_time": "2018-06-01T06:32:51.915376Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-12-3c77ec77605a>:2: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See @{tf.nn.softmax_cross_entropy_with_logits_v2}.\n",
      "\n",
      "Conv/weights:0\n",
      "INFO:tensorflow:Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "Conv/biases:0\n",
      "INFO:tensorflow:Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "Conv_1/weights:0\n",
      "INFO:tensorflow:Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "Conv_1/biases:0\n",
      "INFO:tensorflow:Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "fully_connected/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "fully_connected/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "fully_connected_1/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "fully_connected_1/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "fully_connected_2/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "fully_connected_2/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/david/.local/lib/python3.6/site-packages/tensorflow/python/util/tf_inspect.py:55: DeprecationWarning: inspect.getargspec() is deprecated, use inspect.signature() or inspect.getfullargspec()\n",
      "  if d.decorator_argspec is not None), _inspect.getargspec(target))\n"
     ]
    }
   ],
   "source": [
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "l2_loss = tf.add_n([\n",
    "    tf.nn.l2_loss(w)\n",
    "    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n",
    "])\n",
    "\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES):\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name, w)\n",
    "    \n",
    "total_loss = cross_entropy_loss + 7e-5 * l2_loss\n",
    "tf.summary.scalar('cross_entropy_loss', cross_entropy_loss)\n",
    "tf.summary.scalar('l2_loss', l2_loss)\n",
    "tf.summary.scalar('total_loss', total_loss)\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=0.3).minimize(total_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:25:56.449132Z",
     "start_time": "2018-06-01T06:25:56.438340Z"
    }
   },
   "source": [
    "需要注意的是，上面的网络，最后输出的是未经softmax的原始logits，而不是概率分布，\n",
    "要想看到概率分布，还需要做一下softmax。\n",
    "\n",
    "将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:39:50.010829Z",
     "start_time": "2018-06-01T06:39:49.997501Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/david/.local/lib/python3.6/site-packages/tensorflow/python/util/tf_inspect.py:55: DeprecationWarning: inspect.getargspec() is deprecated, use inspect.signature() or inspect.getfullargspec()\n",
      "  if d.decorator_argspec is not None), _inspect.getargspec(target))\n"
     ]
    }
   ],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(y, 1), tf.argmax(logits, 1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "saver用于保存或恢复训练的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:52.127795Z",
     "start_time": "2018-06-01T06:32:52.103115Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "trainig_step = 1100\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:35:22.270272Z",
     "start_time": "2018-06-01T06:33:18.829198Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.340937, the validation accuracy is 0.9016\n",
      "after 200 training steps, the loss is 0.23556, the validation accuracy is 0.9518\n",
      "after 300 training steps, the loss is 0.25062, the validation accuracy is 0.9598\n",
      "after 400 training steps, the loss is 0.200403, the validation accuracy is 0.9706\n",
      "after 500 training steps, the loss is 0.130072, the validation accuracy is 0.9702\n",
      "after 600 training steps, the loss is 0.23336, the validation accuracy is 0.9718\n",
      "after 700 training steps, the loss is 0.154975, the validation accuracy is 0.9714\n",
      "after 800 training steps, the loss is 0.0854684, the validation accuracy is 0.9782\n",
      "after 900 training steps, the loss is 0.0600702, the validation accuracy is 0.982\n",
      "after 1000 training steps, the loss is 0.0115384, the validation accuracy is 0.9798\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9825\n"
     ]
    }
   ],
   "source": [
    "merged = tf.summary.merge_all()\n",
    "with tf.Session() as sess:\n",
    "\n",
    "    writer = tf.summary.FileWriter(\"logs/\", sess.graph)\n",
    "\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "        keep_prob: 1.0\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0}\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss, rs = sess.run(\n",
    "            [optimizer, cross_entropy_loss, merged],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                keep_prob: 0.6\n",
    "            })\n",
    "        writer.add_summary(rs, i)\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:58:16.766415Z",
     "start_time": "2018-06-01T06:58:15.918700Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-1000\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16],\n",
    "                keep_prob: 1.0\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(\n",
    "                np.argmax(mnist.test.labels[idx]), order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
